use tokio::fs;
use tokio::io::{self, AsyncWriteExt, Result as IoResult};
use std::path::{Path, PathBuf};
use cargo_riir::*;



use clap::{Arg, Command};
use tracing::{info, Subscriber, Level};
use tracing_subscriber::FmtSubscriber;

use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};





#[tokio::main]
async fn main() -> IoResult<()> {
    // 配置环境过滤器，可以从环境变量中读取或默认为 `info`
    let filter_layer = EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| EnvFilter::new("info"));

    // 创建一个向文件追加的层
    let file_appender = tracing_appender::rolling::daily("./logs", "cargo-riir.log");
    let (non_blocking, _guard) = tracing_appender::non_blocking(file_appender);
    let file_layer = fmt::layer()
        .with_writer(non_blocking)
        .with_ansi(false); // 对于文件输出，通常禁用 ANSI 颜色代码

    // 创建一个向标准输出打印的层
    let stdout_layer = fmt::layer().with_writer(std::io::stdout);

    // 组合层并设置为全局默认订阅者
    tracing_subscriber::registry()
        .with(filter_layer)
        .with(stdout_layer)
        .with(file_layer)
        .init();

    info!("Cargo RiiR Start!");

    // let matches = Command::new("cargo-riir")
    //     .version("0.1.0")
    //     .about("Rustify C projects")
    //     .arg(Arg::new("path")
    //          .help("The file or directory to process")
    //          .required(true)
    //          .index(1))
    //     .get_matches();

    let matches = Command::new("cargo-riir")
        .bin_name("cargo") // 设置二进制文件名，模拟 cargo 子命令的行为
        .subcommand(
            Command::new("riir") // 定义子命令，匹配 cargo 后面的子命令名
            .version("0.1.0")
            .about("Rustify C projects")
            .arg(Arg::new("path") // 定义接收的参数
                .help("The file or directory to process")
                .required(true)
                .index(1)),
        )
        .get_matches();

    // 检查并匹配子命令
    if let Some(("riir", sub_matches)) = matches.subcommand() {
        if let Some(path) = sub_matches.get_one::<String>("path") {
            // let path_obj = PathBuf::from(path);
            // 这里执行您的逻辑
            // println!("Processing path: {:?}", path_obj);

            let path = sub_matches.get_one::<String>("path").expect("required and validated by clap");
            let path_obj = PathBuf::from(path);

            if !path_obj.exists() {
                println!("Error: The specified path does not exist: {}", path);
                return Err(io::Error::new(io::ErrorKind::NotFound, "No such file or directory"));
            }

            let output_dir = PathBuf::from("output_dir");

            println!("Processing: {}", path);


            fs::create_dir_all(&output_dir).await?;
            process_path(&path_obj, &output_dir).await?;


            println!("已完毕");
        }
    }
    Ok(())
}


async fn process_path(path: &PathBuf, output_dir: &PathBuf) -> IoResult<()> {
    // 直接使用 code2prompt 函数处理路径，无论是目录还是文件
    let content = cargo_riir::code2prompt(path).expect("you need supply content");
    println!("---------- Input Content ----------- : {}", content);

    // 确定输出路径
    let output_file_path = if path.is_dir() {
        output_dir.join(path.file_name().unwrap()).with_extension("md")
    } else {
        output_dir.join(path.with_extension("md").file_name().unwrap())
    };

    // 确保输出目录存在
    if let Some(parent) = output_file_path.parent() {
        fs::create_dir_all(parent).await?;
    }

    // 使用修改后的 run 函数处理内容，并将处理后的内容输出到指定的路径
    cargo_riir::run(content, output_file_path).await;

    Ok(())
}
